home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / HippoDraw / HippoDrawSrc1.1 / Hippo.subproj / Plot.m < prev    next >
Encoding:
Text File  |  1992-04-25  |  23.7 KB  |  1,070 lines
  1. /* Plot.m  by Jonas Karlsson, July 1990 
  2.  *
  3.  * Copyright (C)  1991  The Board of Trustees of
  4.  * The Leland Stanford Junior University. All Rights Reserved.
  5.  */
  6.  
  7. #import "Plot.h"
  8.  
  9. const char Plot_h_rcsid[] = PLOT_H_ID;
  10. const char Plot_m_rcsid[] = "$Id: Plot.m,v 1.20 1992/04/23 17:15:57 pfkeb Rel $";
  11.  
  12. #import <appkit/Panel.h>
  13. #import <objc/List.h>
  14. #import <objc/Storage.h>
  15.  
  16. #import "HGraphicView.h"
  17. #import "HTuple.h"
  18.  
  19. #import <appkit/nextstd.h>
  20. #import <math.h>
  21. #import <float.h>
  22. #import <dpsclient/wraps.h>
  23.  
  24. #define INDEX_VERSION 2
  25. #define CURRENT_VERSION INDEX_VERSION
  26.  
  27. @implementation Plot
  28.  
  29. static unsigned int plotNum = 0;
  30.  
  31. static NXAtom namePlot() 
  32. {
  33.     char buffer[256];
  34.     
  35.     sprintf( buffer, "HippoPlot.%d", plotNum++);
  36.     return NXUniqueString(buffer);
  37. }
  38.     
  39. static void setMarginRect( NXRect *margins, NXRect *bounds, int grid )
  40. {    
  41.     NXSetRect (margins, 
  42.     0.18 * bounds->size.width,
  43.     0.18 * bounds->size.height,
  44.     bounds->size.width * (1.0 - .26),
  45.     bounds->size.height * (1.0 - .26));
  46.     if ( margins->size.width/grid > 3.001 ) {
  47.         margins->origin.x = bounds->origin.x
  48.                   + MAX( grid*floor( margins->origin.x/grid ), grid );
  49.     margins->size.width = grid*floor( margins->size.width/grid );
  50.     } else {
  51.         margins->origin.x += bounds->origin.x;
  52.     }
  53.     if ( margins->size.height/grid > 3.001) {
  54.         margins->origin.y = bounds->origin.y
  55.                    + MAX( grid*floor( margins->origin.y/grid ), grid );
  56.     margins->size.height = grid*floor( margins->size.height/grid );
  57.     } else {
  58.         margins->origin.y += bounds->origin.y;
  59.     }
  60.     
  61. }
  62. + initialize
  63. {
  64.     [self setVersion:CURRENT_VERSION];
  65.     return self;
  66. }
  67. - init
  68. {
  69.     [super init ];
  70.     uniqueName = namePlot();
  71.     return self;
  72. }
  73. - (const char *)name
  74. {
  75.     return uniqueName;
  76. }
  77. - getDispType:(graphtype_t *) type
  78. {
  79.      *type = h_getDispType(disp);
  80.      return self;
  81. }
  82.  
  83. - setDispType:(graphtype_t *) type
  84. {
  85.     graphtype_t         oldtype;
  86.     const char         *string;
  87.     int                 i;
  88.  
  89.     oldtype = h_getDispType(disp);
  90.     h_setDispType(disp, *type);
  91.     if ((oldtype == HISTOGRAM) && (*type != HISTOGRAM)) {
  92.     i = h_getBinding(disp, XAXIS);
  93.     h_bind(disp, YAXIS, i);
  94.     string = h_getNtLabel([hTuple ntuple], i);
  95.     [self NameAxisY:string];
  96.     }
  97.     if ((oldtype != HISTOGRAM) && (*type == HISTOGRAM)) {
  98.     h_setDrawType(disp, BOX);
  99.     [self NameAxisY:"Entries per bin"];
  100.     }
  101.     return self;
  102. }
  103.  
  104. - setGraphicView:anObject
  105. {
  106.     graphicView = anObject;
  107.     return self;
  108. }
  109. - graphicView
  110. {
  111.     return graphicView;
  112. }
  113. - setHTuple: ht withDisplay:(display) d1
  114. {
  115.     NXRect      margins;
  116.     int        grid;
  117.  
  118.     disp = d1;
  119.     [self replaceTupleWith:ht];
  120.     h_getDrawRect(disp, (rectangle *) &bounds);
  121.     grid = [graphicView gridSpacing];
  122.     setMarginRect(&margins, &bounds, grid );
  123.     h_setMarginRect(disp, (rectangle *) & margins);
  124.     return self;
  125. }
  126. - setRefFlag:(BOOL) flag
  127. {
  128.     h_setNtByRef( disp, flag, NULL );
  129.     return self;
  130. }
  131. - setFixBinsFlag:(BOOL)flag
  132. {
  133.     fixBinsFlag = flag;
  134.     h_setFixedBins( disp, fixBinsFlag );
  135.     return self;
  136. }
  137. - setRefFilename:(const char *)filename
  138. {
  139.     if (!filename) return self;    /* if filename is not legal, return */
  140.     if ( !reffilename ) {
  141.         NX_ZONEMALLOC( [self zone], reffilename, char, strlen(filename)+1 );
  142.     } else {
  143.         NX_ZONEREALLOC( [self zone], reffilename, char, strlen(filename)+1 );
  144.     }
  145.     strcpy( reffilename, filename );
  146.     return self;
  147. }
  148. - changeRefFileNameIfValid:(const char *)filename
  149. {
  150.     if ( !hTuple ) {
  151.         return self;
  152.     }
  153.     if ( [hTuple isFakeFilename] ) {
  154.     if ( !reffilename ) {
  155.         NX_ZONEMALLOC( [self zone], reffilename, char,
  156.                        strlen(filename)+1 );
  157.     } else {
  158.         NX_ZONEREALLOC( [self zone], reffilename, char,
  159.                         strlen(filename)+1 );
  160.     }
  161.     strcpy( reffilename, filename );
  162.     [hTuple setFilename:filename];
  163.     }
  164.     return self;
  165. }
  166. - replaceTupleWith: ht
  167. {
  168.     ntuple    tuple;
  169.     
  170.     hTuple = ht;
  171.     tuple = (hTuple != nil)  ? [hTuple ntuple] : NULL ;
  172.     h_bindNtuple(disp, tuple );
  173.     if ( !tuple ) return self;
  174.     h_setTitle(disp, h_getNtTitle(tuple) );
  175.     [self setRefFilename:[hTuple filename]];
  176.     [self setRefFlag:[hTuple isRef]];
  177.     ntindex = [hTuple index];
  178.     return self;
  179. }
  180. - replace:oldTuple with:newTuple
  181. {
  182.     if ( oldTuple == hTuple ) {
  183.     [self replaceTupleWith:newTuple];
  184.     }
  185.     return self;
  186. } 
  187. - closeTuple
  188. {
  189.     ntuple    tuple;
  190.     
  191.     refFlag = h_getNtByRef(disp);
  192.     fixBinsFlag = h_getFixedBins(disp);
  193.     h_setFixedBins(disp, YES);
  194.     hTuple = nil;
  195.     tuple = NULL;
  196.     h_bindNtuple(disp, tuple );
  197.     return self;
  198. }
  199. - bindReference
  200. {
  201.     if ( reffilename == NULL ) return self;
  202.     if ( !hTuple ) {
  203.     hTuple = [ graphicView hTupleForFile:reffilename index:ntindex];
  204.     }
  205.     if ( disp == NULL ) return self;
  206.     [self replaceTupleWith:hTuple];
  207.     if ( !hTuple ) return self;
  208.     
  209.     h_setFixedBins( disp, fixBinsFlag );
  210.     return self;
  211. }
  212.  
  213. - bindCuts
  214. {
  215.     id            copyStor;
  216.     id            plotList;
  217.     id            plot;
  218.     cutStorElem        *cut;
  219.     dependStorElem    *depend;
  220.     func_id        cut_func;
  221.     unsigned        i, j;
  222.     BOOL        isBound;
  223.     
  224.     if ( cutPlotStor ) {
  225.     copyStor = [cutPlotStor copy ];
  226.     [cutPlotStor empty];
  227.     while ( (cut_func = h_nextCut(disp, NULL) ) ) {
  228.         h_deleteCut(disp, cut_func);
  229.     }
  230.     isBound = NO;
  231.     i = [copyStor count];
  232.     while ( i-- ) {
  233.         cut = [copyStor elementAt: i];
  234.         if ( cut->plot ) {
  235.         [self addCutPlot:cut->plot];
  236.         isBound = YES;
  237.         } else {
  238.         plotList = [graphicView plotList];
  239.         j = [plotList count];
  240.         while ( j-- ) {
  241.             plot = [plotList objectAt:j];
  242.             if ( cut->name == [plot name] ) {
  243.             [self addCutPlot:plot];
  244.             isBound = YES;
  245.             break;
  246.             }
  247.         }
  248.         }
  249.     }
  250.     if ( !isBound ) {
  251.         h_setFixedBins( disp, YES );
  252.     }
  253.     [copyStor free];
  254.     }
  255.     if ( dependStor ) {
  256.         copyStor = [dependStor copy];
  257.     [ dependStor empty];
  258.     i = [copyStor count];
  259.     while ( i-- ) {
  260.         depend = [copyStor elementAt:i];
  261.         if ( depend->plot ) {
  262.             plotList = [depend->plot plotList];
  263.         j = [plotList indexOf:self];
  264.         if ( j == NX_NOT_IN_LIST ) {
  265.             [depend->plot addCutPlot:self];
  266.         } else {
  267.             [dependStor addElement:depend];
  268.         }
  269.         } else {
  270.             plotList = [graphicView plotList];
  271.         j = [plotList count];
  272.         while ( j-- ) {
  273.             plot = [plotList objectAt:j];
  274.             if ( depend->name == [plot name] ) {
  275.                 [plot addCutPlot:self];
  276.             break;
  277.             }
  278.         }
  279.         }
  280.     }
  281.     [graphicView addCut:self];
  282.     }
  283.     return self;
  284. }
  285.  
  286. - hTuple
  287. {
  288.     return hTuple;
  289. }
  290. - (ntuple) ntuple
  291. {
  292.     return [hTuple ntuple];
  293. }
  294. - addHTupleToList:tlist
  295. {
  296.     if ( hTuple ) {
  297.     [tlist addObjectIfAbsent:hTuple];
  298.     }
  299.     return self;
  300. }
  301.  
  302. - addPlotToList:list
  303. {
  304.     [list addObjectIfAbsent:self];
  305.     return self;
  306. }
  307. - (display) histDisplay
  308. {
  309.     return disp;
  310. }
  311.  
  312. - setTitle:(char *) title
  313. {
  314.   h_setTitle(disp, title);
  315.  
  316.   return self;
  317. }
  318. - (char *) title
  319. {
  320.     return ((char *) h_getTitle( disp ) );
  321. }
  322. - NameAxisX:(const char *)AxisName
  323. {
  324.     h_setAxisLabel(disp, XAXIS, AxisName);
  325.     return self;
  326. }
  327. - (const char *) axisLabelX
  328. {
  329.     return h_getAxisLabel(disp, XAXIS );
  330. }
  331. - (const char *) axisLabelY
  332. {
  333.     return h_getAxisLabel(disp, YAXIS );
  334. }
  335. - NameAxisY:(const char *)AxisName
  336. {
  337.     h_setAxisLabel(disp, YAXIS, AxisName);
  338.     return self;
  339. }
  340. - NameAxisW:(const char *)AxisName
  341. {
  342.     h_setAxisLabel(disp, WEIGHT, AxisName);
  343.     return self;
  344. }
  345.  
  346. - NameAxisXE:(const char *)AxisName
  347. {
  348.     h_setAxisLabel(disp, XERROR, AxisName);
  349.     return self;
  350. }
  351.  
  352. - NameAxisYE:(const char *)AxisName
  353. {
  354.     h_setAxisLabel(disp, YERROR, AxisName);
  355.     return self;
  356. }
  357.  
  358. - bindAxisX:(int *)dataDim
  359. {
  360.     h_bind(disp, XAXIS, *dataDim );
  361.     h_setAxisLabel(disp, XAXIS, h_getNtLabel([hTuple ntuple],*dataDim) );
  362.     return self;
  363. }
  364. - bindAxisY:(int *)dataDim
  365. {
  366.     h_bind(disp, YAXIS, *dataDim );
  367.     h_setAxisLabel(disp, YAXIS, h_getNtLabel([hTuple ntuple],*dataDim) );
  368.     return self;
  369. }
  370. - bindAxisW:(int *)dataDim
  371. {
  372.     h_bind(disp, WEIGHT, *dataDim );
  373.     return self;
  374. }
  375.  
  376. - bindAxisXE:(int *)dataDim
  377. {
  378.     h_bind(disp, XERROR, *dataDim );
  379.     return self;
  380. }
  381.  
  382. - bindAxisYE:(int *)dataDim
  383. {
  384.     h_bind(disp, YERROR, *dataDim );
  385.     return self;
  386. }
  387.  
  388. - setLogScaleX:(int *)yesOrNo
  389. {    
  390.     h_setLogAxis(disp,XAXIS,*yesOrNo);
  391.     return self;
  392. }
  393. - (BOOL) isLogScaleX
  394. {
  395.     BOOL    val;
  396.     
  397.     val = h_getLogAxis(disp, XAXIS);
  398.     return val;
  399. }
  400. - setLogScaleY:(int *)yesOrNo
  401. {    
  402.     h_setLogAxis(disp,YAXIS,*yesOrNo);
  403.     return self;
  404. }
  405. - (BOOL) isLogScaleY
  406. {
  407.     BOOL    val;
  408.     
  409.     val = h_getLogAxis(disp, YAXIS);
  410.     return val;
  411. }
  412. - setTitlesFlag:(int *)yesOrNo
  413. {
  414.     h_setDrawTitles( disp, *yesOrNo);
  415.     return self;
  416. }
  417. - (int) titlesFlag
  418. {
  419.     return h_getDrawTitles(disp);
  420. }
  421.  
  422. - setAxesFlag:(int *)yesOrNo
  423. {
  424.     h_setDrawAxes( disp, *yesOrNo );
  425.     return self;
  426. }
  427. - (int) axesFlag
  428. {
  429.     return h_getDrawAxes( disp );
  430. }
  431. - setAutoScaleX:(int *)yesOrNo
  432. {    
  433.      h_setAutoScale(disp,XAXIS,*yesOrNo);
  434.      return self;
  435. }
  436. - setAutoScaleY:(int *)yesOrNo
  437. {    
  438.      h_setAutoScale(disp,YAXIS,*yesOrNo);
  439.      return self;
  440. }
  441.  
  442. - setCutHistFlag: (BOOL) yesOrNo
  443. {
  444.     cutHistFlag = yesOrNo;
  445.     return self;
  446. }
  447.  
  448. - (BOOL) isCutHist
  449. {
  450.     return cutHistFlag;
  451. }
  452.  
  453. - setRangeForAxisX:(NXPoint *)p
  454. {
  455.     h_setRange(disp, XAXIS, p->x, p->y );
  456.     return self;
  457. }
  458. - getRangeForAxisX:(NXPoint *)p
  459. {
  460.     if ( h_getAutoScale( disp, XAXIS ) ) {
  461.         h_setDirty( disp );
  462.     h_bin( disp ); /* in case it hasn't been displayed */
  463.     }
  464.     h_getRange(disp, XAXIS, &p->x, &p->y );
  465.     return self;
  466. }
  467. - setRangeForAxisY:(NXPoint *)p
  468. {
  469.     h_setRange(disp, YAXIS, p->x, p->y );
  470.     return self;
  471. }
  472. - getRangeForAxisY:(NXPoint *)p
  473. {
  474.     if ( h_getAutoScale(disp,YAXIS) ) {
  475.         if ( h_getDispType(disp) == HISTOGRAM ) {
  476.         h_setDirty( disp );
  477.         h_bin( disp ); /* in case it hasn't been displayed */
  478.         h_getBinExtreme(disp, &p->x, &p->y );
  479.     } else {
  480.         h_autoScale(disp);
  481.         h_getRange(disp, YAXIS, &p->x, &p->y );
  482.     }
  483.     } else {
  484.     h_getRange(disp, YAXIS, &p->x, &p->y );
  485.     }
  486.     return self;
  487. }
  488. - getRangeForAxis:(binding_t) axis low:(float *) xl high:(float *) xh
  489. {
  490.     
  491.     if ( h_getAutoScale( disp, axis ) && (axis == YAXIS) ) {
  492.         if ( h_getDispType(disp) == HISTOGRAM ) {
  493.         h_setDirty( disp );
  494.         h_bin( disp ); /* in case it hasn't been displayed */
  495.         h_getBinExtreme(disp, xl, xh );
  496.     } else {
  497.         h_autoScale(disp);
  498.         h_getRange(disp, YAXIS, xl, xh );
  499.     }
  500.     } else {
  501.     h_getRange(disp, axis, xl, xh );
  502.     }
  503.     return self;
  504. }
  505. - setRangesFrom:plot
  506. {
  507.     NXPoint    range;
  508.     graphtype_t    plot_t;
  509.     float    plot_w, my_w;
  510.     int        flag = 0;
  511.  
  512.     if ( plot == self ) {
  513.         return self;
  514.     }
  515.     [plot getRangeForAxisX:&range];
  516.     [self setRangeForAxisX:&range];
  517.     [self setAutoScaleX:&flag];
  518.     [plot getRangeForAxisY:&range];
  519.     if ( h_getDispType(disp) == HISTOGRAM ) {
  520.         [plot getDispType:&plot_t];
  521.     if ( plot_t == HISTOGRAM ) {
  522.         plot_w = [plot widthForAxis:XAXIS];
  523.         my_w = h_getBinWidth(disp, XAXIS);
  524.         range.x = range.x*(my_w/plot_w);
  525.         range.y = range.y*(my_w/plot_w);
  526.         [self setRangeForAxisY:&range];
  527.         [self setAutoScaleY:&flag];
  528.     }
  529.     } else {
  530.     [self setRangeForAxisY:&range];
  531.     [self setAutoScaleY:&flag];
  532.     }
  533.     return self;
  534. }
  535. - getRangeForAxisY:(NXPoint *)range normalizedTo:plot
  536. {
  537.     graphtype_t    plot_t;
  538.     float    plot_w, my_w;
  539.     
  540.     [self getRangeForAxisY:range];
  541.     
  542.     [plot getDispType:&plot_t];
  543.     if ( h_getDispType(disp) != HISTOGRAM || 
  544.                       plot_t != HISTOGRAM    ) {
  545.         return self;
  546.     }
  547.     plot_w = [plot widthForAxis:XAXIS];
  548.     my_w = h_getBinWidth(disp, XAXIS);
  549.     range->x *= (plot_w/my_w);
  550.     range->y *= (plot_w/my_w);
  551.     return self;
  552. }
  553. - (float)widthForAxis:(binding_t) axis
  554. {
  555.     return h_getBinWidth(disp, axis);
  556. }
  557. - setNumBinsForAxisX:(int *) n
  558. {
  559.    h_setBinNum(disp, XAXIS, *n );
  560.    return self;
  561. }
  562.  
  563. - setNumBinsForAxisY:(int *) n
  564. {
  565.    h_setBinNum(disp, YAXIS, *n );
  566.    return self;
  567. }
  568.  
  569. - (int)numBinsForAxis:(binding_t) axis
  570. {
  571.     return h_getBinNum(disp, axis);
  572. }
  573. - setDrawType:(drawtype_t *) type
  574. {
  575.     h_setDrawType(disp, *type);
  576.     return self;
  577. }
  578. - getDrawType:(drawtype_t *) type
  579. {
  580.     *type = h_getDrawType(disp);
  581.     return self;
  582. }
  583. - setColorType:(int *)onOff
  584. {
  585.      int i;
  586.      
  587.      if ( *onOff )
  588.       h_orDrawType(disp, COLOR);
  589.      else
  590.      {
  591.       i = h_getDrawType(disp);
  592.       i = i & (~COLOR);
  593.       h_setDrawType(disp, i);
  594.      }
  595.      return self;
  596. }
  597. - draw
  598. {
  599.         NXRect margins;
  600.         int   grid;
  601.         
  602.         if (bounds.size.width < 1.0 || bounds.size.height < 1.0)
  603.         return self;
  604.  
  605.         if (!NXEqualColor([self fillColor], NX_COLORCLEAR)) {
  606.         [self setFillColor];
  607.         NXRectFill(&bounds);
  608.         }
  609.         if (!NXEqualColor([self lineColor], NX_COLORCLEAR)) {
  610.         [self setLineColor];
  611.         }
  612.        if ( (NXDrawingStatus == NX_PRINTING) && (linewidth < 0.15) ) {
  613.             PSsetlinewidth(0.15);     /* in case going to Linotronic (R) */
  614.         }
  615.     
  616.         h_setDrawRect (disp, (rectangle *) &bounds );
  617.     if ( graphicView ) { 
  618.         grid = [graphicView gridSpacing];
  619.     } else {
  620.         grid = 1;
  621.     }
  622.         setMarginRect( &margins, &bounds, grid );
  623.         h_setMarginRect (disp, (rectangle *) &margins);
  624.  
  625.  /*
  626.  * do shading in case of cut plot. Must do after plotting, since h_plot
  627.  *  sets up margins, autoscales, etc.
  628.  * h_shade will keep shading inside bounds of plot.
  629.  */
  630.     if ( cutHistFlag && (disp != NULL) && (cutParms.cutFunc != NULL) )
  631.     {
  632.          switch (cutParms.cutCode)
  633.          {
  634.          case 0:
  635.           h_shade(disp, -FLT_MAX, cutParms.cutValue1);
  636.           break;
  637.          case 1:
  638.           h_shade(disp, cutParms.cutValue1, FLT_MAX);
  639.           break;
  640.          case 2:
  641.           h_shade(disp, cutParms.cutValue1, cutParms.cutValue2);
  642.           break;
  643.          case 3:
  644.           h_shade(disp, -FLT_MAX, cutParms.cutValue1);
  645.           h_shade(disp, cutParms.cutValue2, FLT_MAX);
  646.           break;
  647.          }          
  648.     }
  649.  
  650.  /*
  651.   * draw plot last, so shading doesn't cover it.
  652.   */
  653.         h_plot(disp);
  654.  
  655.         return self;
  656. }
  657. - print
  658. {
  659.     h_print(disp);
  660.     return self;
  661. }
  662.  
  663. - setBounds:(const NXRect *)aRect
  664. {
  665.     NXRect margins;
  666.     int        grid;
  667.     
  668.     bounds = *aRect;
  669.     h_setDrawRect(disp, (rectangle *)  &bounds);
  670.     grid = [graphicView gridSpacing];
  671.     setMarginRect( &margins, &bounds, grid );    
  672.     h_setMarginRect (disp, (rectangle *) &margins);
  673.     return self;
  674. }
  675.  
  676.  
  677. - sizeToNaturalAspectRatio
  678. {
  679.     NXRect    defaultBox;
  680.     
  681.     [graphicView calcDefaultPlotSize:&defaultBox];
  682.     bounds.origin.y += ( NX_HEIGHT(&bounds) - NX_HEIGHT(&defaultBox) );
  683.     bounds.size.height = NX_HEIGHT(&defaultBox);
  684.     bounds.size.width = NX_WIDTH(&defaultBox);
  685.     [self setBounds:&bounds];
  686.     return self;
  687. }
  688. /* Methods supporting managing cutPlots to this plot */
  689. - addCutPlot: cutPlot
  690. {
  691.     cutStorElem        newcut, *cut;
  692.     dependStorElem    *depend;
  693.     cutParmType         parms;
  694.     int            irc;
  695.     unsigned        i, count;
  696.     
  697.     if ( self == cutPlot ) {
  698.         return self;
  699.     }
  700.     if ( [cutPlot ntuple] != [hTuple ntuple] ) {
  701.         irc = NXRunAlertPanel( "Open",
  702.                    "Attempt to apply cut from different ntuple",
  703.                            "OK", NULL, NULL);
  704.         return self;
  705.     }
  706.     if ( !cutPlotStor ) {
  707.         cutPlotStor = [[Storage allocFromZone:[self zone]] initCount:0
  708.                         elementSize:sizeof(cutStorElem)
  709.                     description:"@%*"];
  710.     }
  711.     
  712.  /* Check if this cutPlot has already been added */
  713.     count = [cutPlotStor count];
  714.     for ( i = 0; i < count; i++ ) {
  715.         cut = [cutPlotStor elementAt:i];
  716.     if ( cut->plot == cutPlot ) {
  717.         return self;
  718.     }
  719.     }
  720.     
  721.  /* Add cutPlot to this plot's list of cuts */
  722.     [cutPlot addCutDepend:self ];
  723.     [cutPlot getCutParms:&parms];
  724.     newcut.plot = cutPlot;
  725.     newcut.name = [cutPlot name];
  726.     newcut.function = h_addCut(disp, parms.cutFunc, parms.varIndex, 
  727.                        parms.cutValue1, parms.cutValue2);
  728.     [cutPlotStor addElement:&newcut];
  729.  
  730.  /* If this plot is a cutting Plot, then add cutPlot to those plots */
  731.     if ( !dependStor ) {
  732.         return self;
  733.     }
  734.     i = [dependStor count];
  735.     if ( !i ) {
  736.         return self;
  737.     }
  738.     while ( i-- ) {
  739.         depend = [dependStor elementAt:i];
  740.     [depend->plot addCutPlot:cutPlot];
  741.     }
  742.     return self;
  743. }
  744. - changeCutPlot:cutPlot
  745. {
  746.     cutStorElem        *cut;
  747.     cutParmType         parms;
  748.     int            i, count;
  749.     
  750.     count = [cutPlotStor count];
  751.     for ( i = 0; i < count; i ++ ) {
  752.         cut = [cutPlotStor elementAt:i];
  753.     if ( cut->plot == cutPlot ) {
  754.         [cutPlot getCutParms:&parms];
  755.         h_changeCut(disp, cut->function,
  756.                     parms.cutValue1, parms.cutValue2);
  757.         break;
  758.     }
  759.     }
  760.     return self;
  761. }
  762. - removeCutPlot:cutPlot
  763. {
  764.     cutStorElem        *cut;
  765.     int            i, count;
  766.     
  767.     
  768.     count = [cutPlotStor count];
  769.     for ( i = 0; i < count; i ++ ) {
  770.         cut = [cutPlotStor elementAt:i];
  771.     if ( cut->plot == cutPlot ) {
  772.         [cutPlot removeCutDepend:self];
  773.             h_deleteCut( disp, cut->function );
  774.         [cutPlotStor removeAt:i];
  775.         break;
  776.     }
  777.     }
  778.     return self;
  779. }
  780. - removeAllCuts
  781. {
  782.     cutStorElem        *cut;
  783.     int            i, count;
  784.     
  785.     
  786.     count = [cutPlotStor count];
  787.     for ( i = 0; i < count; i ++ ) {
  788.         cut = [cutPlotStor elementAt:i];
  789.     [cut->plot removeCutDepend:self];
  790.     h_deleteCut( disp, cut->function );
  791.     }
  792.     [cutPlotStor empty];
  793.     return self;
  794. }
  795. - cutList
  796. {
  797.     cutStorElem        *cut;
  798.     unsigned    i, count;
  799.     
  800.     count = [cutPlotStor count];
  801.     if ( !count ) {
  802.         return nil;
  803.     }
  804.     
  805.     if ( cutPlotList == nil ) {
  806.         cutPlotList = [[List allocFromZone:[self zone]] initCount:0];
  807.     } else {
  808.         [cutPlotList empty];
  809.     }
  810.     for ( i = 0; i < count; i++ ) {
  811.         cut = [cutPlotStor elementAt:i];
  812.     [cutPlotList addObject:cut->plot];
  813.     }
  814.     return cutPlotList;
  815. }
  816. - (BOOL) hasCut
  817. {
  818.     return ( [cutPlotStor count] ? YES : NO );
  819. }
  820. /* Methods used to support plot being used for display for a cut function */
  821. - setCutParms:(cutParmType *) parms
  822. {
  823.     cutParms.cutFunc   = NXCopyStringBuffer( parms->cutFunc );
  824.     cutParms.varIndex  = parms->varIndex;
  825.     cutParms.cutValue1 = parms->cutValue1;
  826.     cutParms.cutValue2 = parms->cutValue2;
  827.     cutParms.cutCode   = parms->cutCode;
  828.     if ( cutParms.cutCode < 2 ) {
  829.         cutParms.blkSize = 2;
  830.     } else {
  831.         cutParms.blkSize = 3;
  832.     }
  833.     
  834.     return self;
  835. }
  836. - getCutParms:(cutParmType *) parms
  837. {
  838.     parms->cutFunc   = cutParms.cutFunc;
  839.     parms->varIndex  = cutParms.varIndex;
  840.     parms->cutValue1 = cutParms.cutValue1;
  841.     parms->cutValue2 = cutParms.cutValue2;
  842.     parms->cutCode   = cutParms.cutCode;
  843.     parms->blkSize   = cutParms.blkSize;
  844.  
  845.     return self;
  846. }    
  847. - addCutDepend:sender
  848. {
  849.     dependStorElem    new, *old;
  850.     unsigned int    i;
  851.     
  852.     if ( !dependStor ) {
  853.         dependStor = [[Storage allocFromZone:[self zone]] initCount:0
  854.                              elementSize:sizeof(dependStorElem)
  855.                          description:"@%"];
  856.     }
  857.     i = [dependStor count];
  858.     while ( i-- ) {
  859.         old = [dependStor elementAt:i];
  860.     if ( old->plot == sender ) {
  861.         return self;
  862.     }
  863.     }
  864.     new.plot = sender;
  865.     new.name = [sender name];
  866.     [dependStor addElement:&new];
  867.     return self;
  868. }
  869. - removeCutDepend:sender
  870. {
  871.     dependStorElem    *old;
  872.     unsigned int    i;
  873.     
  874.     i = [dependStor count];
  875.     while ( i-- ) {
  876.         old = [dependStor elementAt:i];
  877.     if ( old->plot == sender ) {
  878.         [dependStor removeAt:i];
  879.         return self;
  880.     }
  881.     }
  882.     return self;
  883. }
  884. - (unsigned) dependCount
  885. {
  886.     if ( !dependStor ) {
  887.         return 0;
  888.     }
  889.     return [dependStor count];
  890. }
  891. - dependList;
  892. {
  893.     dependStorElem    *old;
  894.     unsigned int    i;
  895.     
  896.     if ( !dependList ) {
  897.         dependList = [[List allocFromZone:[self zone]] initCount:0];
  898.     }
  899.     [dependList empty];
  900.     i = [dependStor count];
  901.     while ( i-- ) {
  902.         old = [dependStor elementAt:i];
  903.     [dependList addObject:old->plot];
  904.     }
  905.     return dependList;
  906. }
  907. - (BOOL) isCutPlot
  908. {
  909.     return cutHistFlag;
  910. }
  911. /* Methods supporting Archiving and de-Archiving */
  912. - write:(NXTypedStream *) ts
  913. {
  914.     cutStorElem        *cut;
  915.     dependStorElem    *old;
  916.     display             dlist[] = {NULL, NULL};
  917.     char        *data;
  918.     int            len, lenref;
  919.     int            i;
  920.  
  921.     [super write:ts];
  922.  
  923.  /* change some flags for storage to stream */
  924.     refFlag = h_getNtByRef(disp);
  925.     fixBinsFlag = h_getFixedBins(disp);
  926.     h_setFixedBins(disp, YES);
  927.     h_setNtByRef(disp, YES, reffilename );
  928.     lenref = strlen(reffilename);
  929.  
  930.  /* write display to buffer */
  931.     len = h_dispSize( disp );
  932.     NX_ZONEMALLOC( [self zone], data, char, len );
  933.     dlist[0] = disp;
  934.     if ( h_writeMem( data, len, dlist, NULL ) ) {
  935.         printf( "Could not write buffer\n" );
  936.     return self;
  937.     }
  938.  
  939.  /* restore display in case we are doing copy */
  940.     h_setNtByRef( disp, refFlag, NULL );
  941.     h_setFixedBins( disp, fixBinsFlag );
  942.         
  943.  /* Now archive Plot object to typed stream */
  944.  
  945.     NXWriteTypes( ts, "ccii",    &refFlag, &fixBinsFlag, &len, &lenref );
  946.     NXWriteType(  ts, "*",       &reffilename );
  947.     if ( [Plot version] >= INDEX_VERSION ) {
  948.         NXWriteType( ts, "i", &ntindex );
  949.         NXWriteObjectReference(ts, hTuple);
  950.     }
  951.     NXWriteArray( ts, "c",       len, data );
  952.     NXWriteType(  ts, "c",       &cutHistFlag);
  953.     if ( cutHistFlag ) {
  954.     len = strlen( cutParms.cutFunc );
  955.         NXWriteType( ts, "i",       &len );
  956.     NXWriteType( ts, "{*iffi}", &cutParms ); 
  957.     NXWriteType( ts, "i",       &cutNumber);
  958.     }
  959.     
  960.     i = [cutPlotStor count];
  961.     NXWriteType( ts, "i", &i );
  962.     while ( i-- ) {
  963.         cut = [cutPlotStor elementAt:i];
  964.     NXWriteObjectReference(ts, cut->plot );
  965.     if ( [Plot version] >= INDEX_VERSION ) {
  966.         cut->name = [cut->plot name];
  967.         NXWriteType( ts, "%", &cut->name );
  968.     }
  969.     }
  970.     if ( dependStor ) {
  971.         i = [dependStor count];
  972.     } else {
  973.         i = 0;
  974.     }
  975.     NXWriteType( ts, "i", &i);
  976.     while ( i-- ) {
  977.         old = [dependStor elementAt:i];
  978.     NXWriteObjectReference( ts, old->plot);
  979.     if ( [Plot version] >= INDEX_VERSION ) {
  980.         old->name = [old->plot name];
  981.         NXWriteType( ts, "%", &old->name );
  982.     }
  983.     }
  984.     
  985.     free( data );    
  986.     
  987.     return self;
  988. }
  989. - read:(NXTypedStream *) ts
  990. {
  991.     cutStorElem        cut;
  992.     dependStorElem    new;
  993.     ntuple        *ntlist;
  994.     display        *dlist;
  995.     char        *data;
  996.     int            len, lenref;
  997.     int            i, count;
  998.     
  999.     [super read:ts];
  1000.     uniqueName = namePlot();
  1001.     NXReadTypes( ts, "ccii",    &refFlag, &fixBinsFlag, &len, &lenref);
  1002.     NX_ZONEMALLOC( [self zone], data, char, len );
  1003.     NX_ZONEMALLOC( [self zone], reffilename, char, lenref+1 );
  1004.     NXReadType(  ts, "*",       &reffilename);
  1005.     if ( NXTypedStreamClassVersion(ts, "Plot") >= INDEX_VERSION ) {
  1006.         NXReadType( ts, "i", &ntindex );
  1007.         hTuple = NXReadObject( ts );
  1008.     } else {
  1009.         ntindex = 0;
  1010.     hTuple = nil;
  1011.     }
  1012.     NXReadArray( ts, "c",       len, data );
  1013.     h_readMem( data, len,  &dlist, &ntlist );
  1014.     NX_FREE( data );
  1015.     disp = dlist[0];
  1016.     NXReadType(  ts, "c",      &cutHistFlag );
  1017.     if ( cutHistFlag ) {
  1018.         NXReadType( ts, "i",       &len );
  1019.     NX_ZONEMALLOC( [self zone], cutParms.cutFunc, char, len+1 );
  1020.     NXReadType( ts, "{*iffi}", &cutParms ); 
  1021.     NXReadType( ts, "i",       &cutNumber);
  1022.     }
  1023.     NXReadType(  ts, "i",       &count );
  1024.     if ( count ) {
  1025.         cutPlotStor = [[Storage allocFromZone:[self zone]] initCount:0
  1026.                              elementSize:sizeof(cutStorElem)
  1027.                          description:"@%*"];
  1028.     }
  1029.     for ( i = 0; i < count; i++ ) {
  1030.         cut.plot = NXReadObject( ts );
  1031.     if ( NXTypedStreamClassVersion(ts, "Plot") >= INDEX_VERSION ) {
  1032.         NXReadType( ts, "%", &cut.name );
  1033.     } else {
  1034.         cut.name = NXUniqueString("HippoPlot.NULL" );
  1035.     }
  1036.     if ( cut.plot ) {
  1037.         cut.name = [cut.plot name];
  1038.     }
  1039.     [cutPlotStor addElement:&cut.plot];
  1040.     }
  1041.     NXReadType( ts, "i", &count );
  1042.     if ( count ) {
  1043.         dependStor = [[Storage allocFromZone:[self zone]] initCount:0
  1044.                              elementSize:sizeof(dependStorElem)
  1045.                          description:"@%"];
  1046.     }
  1047.     for ( i = 0; i < count; i++ ) {
  1048.         new.plot = NXReadObject( ts );
  1049.     if ( NXTypedStreamClassVersion(ts, "Plot") >= INDEX_VERSION ) {
  1050.          NXReadType( ts, "%", &new.name );
  1051.     } else {
  1052.         new.name = NXUniqueString("HippoPlot.NULL" );
  1053.     }
  1054.     if ( new.plot ) {
  1055.         new.name = [new.plot name];
  1056.     }
  1057.         [dependStor addElement:&new];
  1058.     }
  1059.     return self;
  1060. }
  1061. - free
  1062. {
  1063.   /* disp should be attached, but it may not be */
  1064.     if ( disp != NULL ) h_freeDisp(disp);
  1065.     NX_FREE(reffilename);
  1066.     NX_FREE(cutParms.cutFunc);
  1067.     return [super free];
  1068. }
  1069. @end
  1070.